package org.bingo.utils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.BoundSetOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;


/**
 * @author mj
 * @version 1.0
 * @date 2022/3/1 0001 下午 13:49
 * Redis工具类
 **/
@Component
public class RedisUtils {

    @Autowired
    RedisTemplate redisTemplate;

    /**
     * 缓存基本对象，包括String,Integer,实体类对象等类型
     *
     * @param key   缓存目标的key
     * @param value 缓存目标
     */
    public void setValue(String key, Object value) {
        redisTemplate.opsForValue().set(key, value);
    }

    /**
     * 缓存基本对象，包括String,Integer,实体类对象等类型并设置超时时间
     *
     * @param key      缓存目标的key
     * @param value    缓存目标
     * @param timeout  超时时间
     * @param timeUnit 时间粒度
     */
    public void setValueByExpire(String key, Object value, Integer timeout, TimeUnit timeUnit) {
        redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
    }

    /**
     * 缓存基本对象，包括String,Integer,实体类对象等类型并设置超时时间4
     * 默认时间粒度是秒级
     *
     * @param key     缓存目标的key
     * @param value   缓存目标
     * @param timeout 超时时间
     */
    public void setValueByExpire(String key, Object value, Integer timeout) {
        redisTemplate.opsForValue().set(key, value, timeout, TimeUnit.SECONDS);
    }

    /**
     * 设置key的有效时间
     * 默认时间粒度是秒级
     *
     * @param key     缓存目标的key
     * @param timeout 有效时间
     */
    public boolean expire(String key, Object value, long timeout) {
        return redisTemplate.expire(key, timeout, TimeUnit.SECONDS);
    }

    /**
     * 设置key的有效时间
     *
     * @param key      缓存目标的key
     * @param timeout  有效时间
     * @param timeUnit 时间粒度
     */
    public boolean expire(String key, Object value, long timeout, TimeUnit timeUnit) {
        return redisTemplate.expire(key, timeout, timeUnit);
    }

    /**
     * 通过特定key获取缓存中的值
     *
     * @param key 目标key
     * @return 目标值
     */
    public Object getValue(String key) {
        return redisTemplate.opsForValue().get(key);
    }

    /**
     * 通过特定key删除缓存中的值
     *
     * @param key 目标key
     */
    public boolean deleteValue(String key) {
        return redisTemplate.delete(key);
    }

    /**
     * 通过批量key批量删除对象
     *
     * @param collection 目标key集合
     */
    public long deleteValue(Collection collection) {
        return redisTemplate.delete(collection);
    }

    /**
     * 缓存集合对象
     *
     * @param key
     * @param dataList
     * @return
     */
    public long setList(String key, List<Object> dataList) {
        return redisTemplate.opsForList().rightPush(key, dataList);
    }

    /**
     * 获取缓存的集合对象
     *
     * @param key
     * @return
     */
    public List<Object> getList(String key) {
        return redisTemplate.opsForList().range(key, 0, -1);
    }


    /**
     * 缓存set集合
     *
     * @param key
     * @param dataSet
     * @return
     */
    public BoundSetOperations<String, Object> setSet(String key, Set<Object> dataSet) {
        BoundSetOperations setOperations = redisTemplate.boundSetOps(key);
        dataSet.forEach(item -> setOperations.add(item));
        return setOperations;
    }

    /**
     * 获取缓存的set数据
     *
     * @param key
     * @return
     */
    public Set<Object> getSet(String key) {
        return redisTemplate.opsForSet().members(key);
    }

    /**
     * 缓存map对象
     *
     * @param key
     * @param dataMap
     */
    public void setMap(String key, Map<String, Object> dataMap) {
        redisTemplate.opsForHash().putAll(key, dataMap);
    }

    /**
     * 获取缓存map对象
     * @param key
     */
    public Map<String, Object> getMap(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * 缓存hash数据类型
     * @param key
     * @param hkey
     * @param value
     */
    public void setMapValue(String key,String hkey,Object value){
    redisTemplate.opsForHash().put(key,hkey,value);
    }

    /**
     * 获取缓存hash数据类型
     * @param key
     * @param hkey
     */
    public Object setMapValue(String key,String hkey){
        return redisTemplate.opsForHash().get(key,hkey);
    }

    /**
     * 删除缓存的hash数据类型
     * @param key
     * @param hkey
     * @return
     */
    public Long deleteMapValue(String key,String hkey){
        return redisTemplate.opsForHash().delete(key,hkey);
    }

    /**
     * 删除多个hash类型数据
     * @param key
     * @param hkeys
     * @return
     */
    public List<Object> deleteMapValues(String key,Collection<Object> hkeys){
        return redisTemplate.opsForHash().multiGet(key,hkeys);
    }

    /**
     * 返回所有的缓存对象
     * @param pattern
     * @return
     */
    public Collection<String> keys(String pattern){
        return redisTemplate.keys(pattern);
    }
}
